home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / libg_261.zip / libg_261 / libg++ / old-stream / File.cc < prev    next >
C/C++ Source or Header  |  1992-08-12  |  11KB  |  581 lines
  1. /* 
  2. Copyright (C) 1988 Free Software Foundation
  3.     written by Doug Lea (dl@rocky.oswego.edu)
  4.  
  5. This file is part of the GNU C++ Library.  This library is free
  6. software; you can redistribute it and/or modify it under the terms of
  7. the GNU Library General Public License as published by the Free
  8. Software Foundation; either version 2 of the License, or (at your
  9. option) any later version.  This library is distributed in the hope
  10. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  11. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  12. PURPOSE.  See the GNU Library General Public License for more details.
  13. You should have received a copy of the GNU Library General Public
  14. License along with this library; if not, write to the Free Software
  15. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  16. */
  17.  
  18. #ifdef __GNUG__
  19. #pragma implementation
  20. #endif
  21. #include <File.h>
  22. #include <std.h>
  23. #include <stdarg.h>
  24. #include <values.h>
  25. #include <sys/file.h>           // needed to determine values of O_RDONLY...
  26.  
  27.  
  28. #ifdef VMS
  29. #include <errno.h>    // needed to get the psect magic loaded
  30. #define    FP    (*fp)
  31. #else
  32. #define    FP    fp
  33. #endif
  34.  
  35. // error handlers
  36.  
  37. void verbose_File_error_handler(const char* msg)
  38. {
  39.   perror(msg);
  40.   errno = 0;
  41. }
  42.  
  43. void quiet_File_error_handler(const char*)
  44. {
  45.   errno = 0;
  46. }
  47.  
  48. void fatal_File_error_handler(const char* msg)
  49. {
  50.   perror(msg);
  51.   exit(1);
  52. }
  53.  
  54. one_arg_error_handler_t File_error_handler = verbose_File_error_handler;
  55.  
  56.  
  57. one_arg_error_handler_t set_File_error_handler(one_arg_error_handler_t f)
  58. {
  59.   one_arg_error_handler_t old = File_error_handler;
  60.   File_error_handler = f;
  61.   return old;
  62. }
  63.  
  64.  
  65. /*
  66.  
  67.  Opening files. 
  68.  
  69.  open(filename, io_mode, access_mode) is done via system open 
  70.  command since fopen doesn't handle all of the cases possible 
  71.  with sys open. After a successful open, fdopen is called to 
  72.  attach an _iobuf to the file descriptor.
  73.  
  74.  All this requires a few decoding routines that can translate among our
  75.  enumerated types, system flags, and fopen modes.
  76.  
  77. */
  78.  
  79.  
  80. enum sys_open_cmd_io_mode  // These should be correct for most systems
  81. {                        
  82.   sio_read      = O_RDONLY,
  83.   sio_write     = O_WRONLY,
  84.   sio_readwrite = O_RDWR,
  85.   sio_append    = O_APPEND
  86. };
  87.  
  88. enum sys_open_cmd_access_mode
  89. {
  90.   sa_create     = O_CREAT,
  91.   sa_truncate   = O_TRUNC,
  92.   sa_createonly = O_EXCL | O_CREAT
  93. };
  94.  
  95.   
  96. static int open_cmd_arg(io_mode i, access_mode a) // decode modes
  97. {
  98.   int arg;
  99.   switch(i)
  100.   {
  101.   case io_readonly:   arg = sio_read;                   break;
  102.   case io_writeonly:  arg = sio_write;                  break;
  103.   case io_readwrite:  arg = sio_readwrite;              break;
  104.   case io_appendonly: arg = sio_append | sio_write;     break;
  105.   case io_append:     arg = sio_append | sio_readwrite; break;
  106.   default:            return -1;
  107.   };
  108.   switch(a)
  109.   {
  110.   case a_createonly:  return arg | sa_createonly;
  111.   case a_create:      return arg | sa_create | sa_truncate;
  112.   case a_useonly:     return arg;
  113.   case a_use:         return arg | sa_create;
  114.   default:            return -1;
  115.   }
  116. }
  117.  
  118. static char* fopen_cmd_arg(io_mode i)
  119. {
  120.   switch(i)
  121.   {
  122.   case io_readonly:  return "r";
  123.   case io_writeonly: return "w";
  124.   case io_readwrite: return "r+";
  125.   case io_appendonly:return "a";
  126.   case io_append:    return "a+";
  127.   default:           return 0;
  128.   }
  129. }
  130.  
  131.  
  132. void File::initialize() 
  133. { 
  134.   fp = 0; nm = 0; stat = 0; state = _bad; rw = 0;
  135. }
  136.  
  137. // reset class vars after open
  138. // fp->_flag inspection is isolated here
  139.  
  140. void File::reinitialize(const char* filename)
  141. {
  142.   if (filename != 0)     setname(filename);
  143.   else if (fp == stdin)  setname("(stdin)");
  144.   else if (fp == stdout) setname("(stdout)");
  145.   else if (fp == stderr) setname("(stderr)");
  146.   else if (rw & 4)       setname("(string)");
  147.   else setname(0);
  148.  
  149.   if (fp != 0)
  150.   {
  151.     state = _good;
  152.     if (FP->_flag & (_IOREAD|_IORW))
  153.       rw |= 01;
  154.     if (FP->_flag & (_IOWRT|_IORW))
  155.       rw |= 02;
  156.     check_state();
  157.   }
  158.   else
  159.   {
  160.     set(_fail); set(_bad);
  161.     error();
  162.   }
  163. }
  164.  
  165.  
  166. File& File::open(const char* filename, io_mode m, access_mode a)
  167. {                                   
  168.   close();
  169.   int open_arg = open_cmd_arg(m, a);
  170.   if (open_arg != -1)
  171.   {
  172.     int fd = ::open(filename, open_arg, 0666);
  173.     if (fd >= 0)
  174.       fp = fdopen(fd, fopen_cmd_arg(m));
  175.   }
  176.   reinitialize(filename);
  177.   return *this;
  178. }
  179.  
  180. File& File::open(const char* filename, const char* m)
  181. {                                   
  182.   close();
  183.   fp = fopen(filename, m);
  184.   reinitialize(filename);
  185.   return *this;
  186. }
  187.  
  188. File& File::open(FILE* fileptr)
  189. {
  190.   close();
  191.   fp = fileptr;
  192.   reinitialize(0);
  193.   return *this;
  194. }
  195.  
  196. File& File::open(int filedesc, io_mode m)
  197. {
  198.   close();
  199.   fp = fdopen(filedesc, fopen_cmd_arg(m));
  200.   reinitialize(0);
  201.   return *this;
  202. }
  203.  
  204. File& File::close()
  205. {
  206.   if (fp != 0)
  207.   {
  208. #ifdef VMS
  209.     if (rw & 4)                 // we own the iobuf, kill it
  210.       delete(*fp);    // kill the _iobuf
  211. #endif
  212.     if (rw & 4)                 // we own the iobuf, kill it
  213.       delete fp;
  214.     else if (fp == stdin || fp == stdout || fp == stderr)
  215.       flush();
  216.     else
  217.       fclose(fp);
  218.   }
  219.   fp = 0;
  220.   rw = 0;
  221.   set(_bad);
  222.   return *this;
  223. }
  224.  
  225. File& File::remove()
  226. {
  227.   close();
  228.   return failif (nm == 0 || unlink(nm) != 0);
  229. }
  230.  
  231.  
  232. File::File()
  233. { 
  234.   initialize(); 
  235. }
  236.  
  237. File::File(const char* filename, io_mode m, access_mode a)   
  238. { 
  239.   initialize(); 
  240.   open(filename, m, a); 
  241. }
  242.  
  243. File::File(const char* filename, const char* m)   
  244. { 
  245.   initialize(); 
  246.   open(filename, m); 
  247. }
  248.  
  249. File::File(int filedesc, io_mode m)
  250. { 
  251.   initialize(); 
  252.   open(filedesc, m); 
  253. }
  254.  
  255. File::File(FILE* fileptr)
  256. { 
  257.   initialize(); 
  258.   open(fileptr); 
  259. }
  260.  
  261. File::File(int sz, char* buf, io_mode m)
  262. {
  263.   if (m != io_readonly && m != io_writeonly)
  264.     (*File_error_handler) ("invalid io_mode for string IO");
  265.   initialize();
  266.   rw = 4;
  267. #ifdef VMS
  268.   _iobuf    *iob;
  269.   FILE        *f;
  270.  
  271.   iob = new _iobuf;
  272.   f = new(FILE);
  273.   *f = iob;
  274.   fp = f;
  275. #else
  276.   fp = new _iobuf;
  277. #endif
  278. #ifndef _NFILE
  279.   FP->_file = 255;          // any illegal value
  280. #else
  281.   FP->_file = _NFILE-1;       // The last filedescriptor...
  282. #ifdef BUFEND_ENTRY_TYPE
  283.   _bufendtab[FP->_file] = (BUFEND_ENTRY_TYPE)buf+sz-1;
  284. #endif
  285. #endif
  286.   FP->_ptr = FP->_base = buf;
  287. #ifdef HAVE_BUFSIZ
  288.   FP->_bufsiz = sz;
  289. #endif
  290.   if (m == io_readonly)
  291.   {
  292.     int len = 0;
  293.     while (len < sz && buf[len] != 0) ++len;
  294.     if (len == sz)
  295.       buf[sz - 1] = 0;            // force null-termination!
  296.     FP->_cnt = len;
  297.     FP->_flag = _IOREAD | _IOSTRG | _IOMYBUF;
  298.   }
  299.   else
  300.   {
  301.     bzero(buf, sz);             // so any result will be null-terminated
  302.     FP->_cnt = sz - 1;          // leave at least one null at end
  303.     FP->_flag = _IOWRT | _IOSTRG | _IOMYBUF;
  304.   }
  305.   reinitialize(0);
  306. }
  307.  
  308. File::~File()
  309. {
  310.   delete(nm);
  311.   close();
  312. }
  313.  
  314. void File::setname(const char* newname)
  315. {
  316.   if (nm == newname) return;
  317.  
  318.   if (nm != 0)
  319.     delete(nm);
  320.   if (newname != 0)
  321.   {
  322.     nm = new char[strlen(newname) + 1];
  323.     strcpy(nm, newname);
  324.   }
  325.   else
  326.     nm = 0;
  327. }
  328.  
  329.  
  330. File& File::setbuf(int buffer_kind)
  331. {                  
  332.   if (!is_open())
  333.   {
  334.     set(_fail);
  335.     return *this;
  336.   }
  337.   switch(buffer_kind)
  338.   {
  339.   case _IOFBF:       
  340. #ifdef HAVE_SETVBUF
  341.     setvbuf(fp, 0, _IOFBF, 0);
  342. #endif
  343.     break;           
  344.   case _IONBF:       
  345.     ::setbuf(fp, 0); 
  346.     break;
  347.   case _IOLBF:
  348. #ifdef HAVE_SETLINEBUF
  349.     setlinebuf(fp);
  350. #else
  351. #ifdef HAVE_SETVBUF
  352.     setvbuf(fp, 0, _IOLBF, 0);
  353. #endif
  354. #endif    
  355.     break;
  356.   default:
  357.     break;
  358.   }
  359.   return *this;
  360. }
  361.  
  362. File& File::setbuf(int size, char* buf)
  363. {
  364.   if (!is_open())
  365.   {
  366.     set(_fail);
  367.     return *this;
  368.   }
  369. #ifdef HAVE_SETVBUF
  370.   setvbuf(fp, buf, _IOFBF, size);
  371. #else
  372.   setbuffer(fp, buf, size);
  373. #endif
  374.   return *this;
  375. }
  376.  
  377. void File::error()
  378. {
  379.   check_state();
  380.   set(_fail);
  381.   if (errno != 0)
  382.   {
  383.     char error_string[400];
  384.     strcpy(error_string, "\nerror in File ");
  385.     if (nm != 0)
  386.       strcat(error_string, nm);
  387.     (*File_error_handler)(error_string);
  388.   }
  389. }
  390.  
  391.  
  392. //------------------------------------------------------------------
  393.  
  394. void File::check_state() // ensure fp & state agree about eof
  395. {
  396.   if (fp != 0)
  397.   {
  398.     if (feof(fp))
  399.       set(_eof);
  400.     else
  401.       unset(_eof);
  402.     if (ferror(fp))
  403.       set(_bad);
  404.   }
  405. }
  406.  
  407. File& File::put(const char* s)
  408. { 
  409.   return failif(!writable() || fputs(s, fp) == EOF);
  410. }
  411.  
  412. File& File::get(char* s, int n, char terminator)
  413. {
  414.   if (!readable())
  415.   {
  416.     set(_fail);
  417.     return *this;
  418.   }
  419.  
  420.   char ch;
  421.   stat = --n;
  422.  
  423.   if (n > 0 && (get(ch)))
  424.   {
  425.     if (ch == terminator) {
  426.       unget(ch);
  427.       stat= 0;    // This is not an error condition !
  428.     }
  429.     else
  430.     {
  431.       *s++ = ch; --n;
  432.       while (n > 0 && (get(ch)))
  433.       {
  434.         if (ch == terminator)
  435.         {
  436.           unget(ch);
  437.           break;
  438.         }
  439.         else
  440.         {
  441.           *s++ = ch; --n;
  442.         }
  443.       }
  444.     }
  445.   }
  446.  
  447.   *s = 0;
  448.   return failif((stat != 0) && ((stat -= n) == 0));
  449. }
  450.  
  451. File& File::getline(char* s, int n, char terminator)
  452. {
  453.   if (!readable())
  454.   {
  455.     set(_fail);
  456.     return *this;
  457.   }
  458.  
  459.   char ch;
  460.   stat = --n;
  461.  
  462.   while (n > 0 && (get(ch)))
  463.   {
  464.     --n;
  465.     if ((*s++ = ch) == terminator)
  466.       break;
  467.   }
  468.  
  469.   *s = 0;
  470.   return failif((stat != 0) && ((stat -= n) == 0));
  471. }
  472.  
  473. // from Doug Schmidt
  474.  
  475. // This should probably be a page size....
  476. #define CHUNK_SIZE 512
  477.  
  478. /* Reads an arbitrarily long input line terminated by a user-specified
  479.    TERMINATOR.  Super-nifty trick using recursion avoids unnecessary calls
  480.    to NEW! */
  481.  
  482. char *File::readline (int chunk_number, char terminator) 
  483. {
  484.   char buf[CHUNK_SIZE];
  485.   register char *bufptr = buf;
  486.   register char *ptr;
  487.   char ch;
  488.   int continu;
  489.  
  490.   while ((continu = !!get(ch)) && ch != terminator) /* fill the current buffer */
  491.     {
  492.       *bufptr++ = ch;
  493.       if (bufptr - buf >= CHUNK_SIZE) /* prepend remainder to ptr buffer */
  494.         {
  495.           if (ptr = readline (chunk_number + 1, terminator))
  496.  
  497.             for (; bufptr != buf; *--ptr = *--bufptr);
  498.  
  499.           return ptr;
  500.         }
  501.     }
  502.   if (!continu && bufptr == buf)
  503.     return NULL;
  504.  
  505.   int size = (chunk_number * CHUNK_SIZE + bufptr - buf) + 1;
  506.  
  507.   if (ptr = new char[stat = size])
  508.     {
  509.  
  510.       for (*(ptr += (size - 1)) = '\0'; bufptr != buf; *--ptr = *--bufptr)
  511.         ;
  512.  
  513.       return ptr;
  514.     } 
  515.   else 
  516.     return NULL;
  517. }
  518.  
  519. /* Reads an arbitrarily long input line terminated by TERMINATOR.
  520.    This routine allocates its own memory, so the user should
  521.    only supply the address of a (char *). */
  522.  
  523. File& File::gets(char **s, char terminator)
  524. {
  525.   if (!readable())
  526.   {
  527.     set(_fail);
  528.     return *this;
  529.   }
  530.  
  531.   return failif(!(*s = readline (0, terminator)));
  532. }
  533.   
  534. #ifndef VMS
  535. File& File::scan(const char* fmt ...)
  536. {
  537.   if (readable())
  538.   {
  539.     va_list args;
  540.     va_start(args, fmt);
  541. #ifndef HAVE_VSCANF
  542.     stat = _doscan(fp, fmt, args);
  543. #else
  544.     stat = vfscanf(fp, fmt, args);
  545. #endif
  546.     va_end(args);
  547.     failif(stat <= 0);
  548.   }
  549.   return *this;
  550. }
  551. #endif
  552.  
  553. File& File::form(const char* fmt ...)
  554. {
  555.   va_list args;
  556.   va_start(args, fmt);
  557. #ifndef HAVE_VPRINTF
  558.   stat = _doprnt(fmt, args, fp);
  559. #ifdef HAVE_VOID_DOPRNT
  560.   stat = ferror(fp) ? -1 : 0;
  561. #endif
  562. #else
  563.   stat = vfprintf(fp, fmt, args);
  564. #endif
  565.   va_end(args);
  566.   failif(stat < 0);
  567.   return *this;
  568. }
  569.  
  570. #ifdef VMS
  571. extern "C" {
  572.     unlink(const char *s)
  573.     {
  574.         int remove(const char *);
  575.  
  576.         return remove(s);
  577.     }
  578. }
  579. #endif
  580.  
  581.